#include "TableauDynamique.h"
#include "ElementTD.h"
#include <stdio.h>
#include <stdlib.h>

void initialiserTabDyn(TableauDynamique * t)
/* Precondition : t non prealablement initialise */
/* Postcondition : t initialise a une alveole vide (taille utilisee nulle) */
{
      (*t).taille_utilisee=0;
      (*t).capacite=1;
      (*t).ad=malloc((*t).capacite * sizeof(ElementTD));
}

void testamentTabDyn(TableauDynamique *t)
/* Precondition : t prealablement initialise */
/* Postcondition : t pret a disparaitre. La memoire allouee dynamiquement
   est liberee. On ne pourra plus appeler les sous-programmes qui
   necessitent que t soit initialise. */
{
 
   if ((*t).ad !=NULL)
   {
      free((*t).ad);
      (*t).ad=NULL;
      (*t).capacite=0;
      (*t).taille_utilisee=0;
      
   }

}


void ajouterElementTabDyn(TableauDynamique *t, ElementTD e)
/* Precondition : t prealablement initialise */
/* Postcondition : L'element e est ajoute dans la premiere alveole inutilisee 
   du tableau, la taille utilisee est incrementee de 1. Doublement de la 
   capacite de t, si necessaire. */
{
  
   int i;
  if (t->capacite == t->taille_utilisee)
  
  {
     ElementTD *temp= t->ad;
     t->ad=malloc(2*t->capacite*sizeof(ElementTD));
     for (i=0;i<t->capacite;i++)
     {
         t->ad[i]=temp[i];
         
     }
     t->capacite*=2;
     free (temp);
  }
  t->ad[t->taille_utilisee]=e;
  t->taille_utilisee++;

}


ElementTD valeurIemeElementTabDyn(const TableauDynamique *t, unsigned int i)
/* Precondition : t prealablement initialise, 0 <= i < tailleUtilisee(t) */
/* Resultat : retourne le i+1eme ElementTD de t */
{
  int j;
  
  for (j=0;j<(*t).taille_utilisee;j++)
  {
     if (j==i)
     {
        return t->ad[i];
        
     }
  }
  return -1;
  
}


void modifierValeurIemeElementTabDyn(TableauDynamique *t, ElementTD e, unsigned int i)
/* Precondition : t prealablement initialise et 0 <= i < tailleUtilisee(t) */
/* Postcondition : le i+1eme ElementTD de t vaut e */

{
        int j;
        for (j=0;j<(*t).taille_utilisee;j++)
        {
             if (j==i)
             {
              t->ad[j]=e;
             }
        }
}


void afficherTabDyn(const TableauDynamique *t)
/* Precondition : t prealablement initialise */
/* Postcondition : Les elements du tableau sont affiches sur la sortie
   standard en utilisant la procedure d'affichage definie dans le module
   ElementTD. */

{
   int i;
   for (i=0;i<(*t).taille_utilisee;i++)
   {
       afficheElementTD((*t).ad[i]);
   }
}



void supprimerElementTabDyn( TableauDynamique *t, int position )
/* Precondition : t prealablement initialise et non vide */
/* Postcondition : la taille utilisee du tableau est decrementee de 1. Si   
   tailleUtilisee < capacite/3, alors on divise la capacité par 2. */

{
  
  int i,j;
  
  for (i=0;i<(*t).capacite;i++)
  {
     if (i==position)
     {
         for (j=position;j<(*t).capacite;j++)
         {
         	(*t).ad[j]=(*t).ad[j+1];
         }
     }  
  }
  (*t).taille_utilisee--;
  
  /*gestion memoire*/
  if ((*t).taille_utilisee<(*t).capacite/3)
  {
  	ElementTD *temp= malloc ((*t).capacite/2 * sizeof(ElementTD));
  	(*t).capacite=(*t).capacite/2;
  	temp=(*t).ad;
  	for (j=0;j<(*t).capacite;j++)
  	{
  	   (*t).ad[j]=temp[j];
  	}
  	free (temp);
  }

}


void affecterTabDyn(TableauDynamique *t1, const TableauDynamique *t2)
/* Precondition : t1 et t2 initialises */
/* Postcondition : l'ancien contenu de t1 est perdu. t1 et t2 contiennent 
   des sequences d'ElementTD identiques (t1 correspond a une copie de t2, 
   les 2 tableaux ont meme capacite, meme taille utilisee, mais sont 
   independants) */
   
{


  int i;
  t1->capacite= t2->capacite;
  t1->taille_utilisee= t2->taille_utilisee;
  t1->ad= malloc (t2->capacite * sizeof(ElementTD));
  for (i=0;i<t2->capacite;i++)
  {
      t1->ad[i]=t2->ad[i];
  }
  
 
 
}   


void affecterTabDynInverse(TableauDynamique *t1, const TableauDynamique *t2)

   
{


  int i;
  t1->capacite= t2->capacite;
  t1->taille_utilisee= t2->taille_utilisee;
  t1->ad= malloc (t2->capacite * sizeof(ElementTD));
  for (i=0;i<t2->taille_utilisee;i++)
  {
      t1->ad[i]=t2->ad[(t2->taille_utilisee-1) -i];
  }
  
 
 
}


void fusionnerTabDyn (const TableauDynamique *t1,const TableauDynamique *t2, TableauDynamique *t3) /*cc tp*/
{
      
  int i,j,k;
  t3->capacite= (t2->capacite)+(t1->capacite);
  t3->taille_utilisee= (t2->taille_utilisee)+(t1->taille_utilisee);
  t3->ad= malloc (t3->capacite * sizeof(ElementTD));
  
  for (i=0;i<t1->taille_utilisee;i++)
  {
     t3->ad[i]=t1->ad[i];
  }
    
  
   
  for (k=(t1->taille_utilisee);k<t3->taille_utilisee;k++)
  {
     for (j=0;j<t2->taille_utilisee;j++)
     {
        t3->ad[k]=t2->ad[k-t2->taille_utilisee];
     }   
  }    
      
      
}

/*
int rechercherElementTabDyn(const TableauDynamique * t, ElementTD e,int taille)
{
   if (1==estEgal(e,t->ad[0]))
   {
     return 0;
   }
   if (1==estEgal(e,t->ad[(*t).taille_utilisee]))
   {
     return (taille-1);
   }
   
  
   return recherche (t,e,0,taille-1);
}


int recherche(const TableauDynamique *t, ElementTD e, int id, int ifin)
{
  int im;
  if ( (ifin - id)==1)
  {
     return -1;
     
  }
  
  im = (ifin +id)/2;
  if (t->ad[im]==e)
  {
     return im;
  }
  
  if (1==estStrictementInferieur(e,t->ad[im]))
  {
        return recherche (t,e,id,im);
  }
  else 
  {
  	return recherche (t,e,im,ifin);
  }
  
  

}
*/




